// 封装uni-app请求方法
const BASE_URL = 'http://localhost:8080'; // 后端服务器地址
const API_PREFIX = '/api';

// 智能处理 API 前缀
const processUrl = (url) => {
    // 如果 URL 已经以 /api 开头，直接返回
    if (url.startsWith('/api')) {
        return url;
    }
    // 如果 URL 不是以 /api 开头，添加前缀
    return API_PREFIX + (url.startsWith('/') ? url : '/' + url);
};

// 检查token是否存在且有效
const checkToken = () => {
    const token = uni.getStorageSync('token');
    if (!token) {
        console.error('没有找到token，需要登录');
        // 如果没有token，跳转到登录页
        uni.reLaunch({
            url: '/pages/login/login'
        });
        return false;
    }
    console.log('已找到token:', token);
    return true;
};

// 创建请求头
const createHeaders = (requireAuth = true) => {
    const headers = {
        'Content-Type': 'application/json'
    };
    if (requireAuth) {
        const token = uni.getStorageSync('token');
        if (token) {
            console.log('添加认证头:', token);
            // 已经包含Bearer前缀的token直接使用，否则添加前缀
            headers['Authorization'] = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
            console.log('最终认证头:', headers['Authorization']);
        } else {
            console.error('无法创建认证头，token不存在');
        }
    }
    return headers;
};

// 处理响应数据
const handleResponse = (res) => {
    console.log('收到响应:', JSON.stringify(res));
    
    // 检查HTTP状态码
    if (res.statusCode === 200) {
        // API响应格式 { code: 200, message: "success", data: {...} }
        if (res.data && res.data.code === 200) {
            return res.data;
        } else if (res.data && res.data.status === 1 && res.data.code === 200) {
            // 处理另一种成功响应格式
            return res.data;
        } else {
            console.error('API错误响应:', JSON.stringify(res.data));
            
            // 检查是否有详细错误信息
            let errorMsg = res.data?.message || res.data?.error || '请求失败';
            let errorCode = res.data?.code || 500;
            
            console.error(`API错误: [${errorCode}] ${errorMsg}`);
            
            // 检查是否是认证错误，更精确的判断条件
            if (res.data?.code === 401) {
                // 确认是token过期
                console.error('检测到认证错误 (401)，即将跳转到登录页面', res.data);
                console.error('当前token:', uni.getStorageSync('token'));
                console.error('当前用户信息:', JSON.stringify(uni.getStorageSync('userInfo')));
                
                uni.removeStorageSync('token');
                uni.removeStorageSync('userInfo');
                
                // 使用setTimeout避免在回调中立即跳转导致的问题
                setTimeout(() => {
                uni.reLaunch({
                    url: '/pages/login/login'
                });
                }, 100);
            }
            
            // 返回错误响应而不是抛出错误
            return {
                success: false,
                code: errorCode,
                message: errorMsg,
                data: null
            };
        }
    } else if (res.statusCode === 401) {
        // token过期或无效，清除token并跳转到登录页
        console.error('认证失败 (401):', JSON.stringify(res.data));
        console.error('当前token:', uni.getStorageSync('token'));
        console.error('当前用户信息:', JSON.stringify(uni.getStorageSync('userInfo')));
        
        uni.removeStorageSync('token');
        uni.removeStorageSync('userInfo');
        
        // 使用setTimeout避免在回调中立即跳转导致的问题
        setTimeout(() => {
        uni.reLaunch({
            url: '/pages/login/login'
        });
        }, 100);
        
        return {
            success: false,
            code: 401,
            message: '登录已过期，请重新登录',
            data: null
        };
    } else if (res.statusCode === 403) {
        console.error('权限不足 (403):', JSON.stringify(res.data));
        // 返回错误响应而不是抛出错误，让调用者处理
        return {
            success: false,
            code: 403,
            message: res.data?.message || '没有权限访问该资源',
            data: null
        };
    } else if (res.statusCode === 404) {
        console.error('请求的资源不存在 (404):', JSON.stringify(res.data));
        // 返回错误响应而不是抛出错误，让调用者处理
        return {
            success: false,
            code: 404,
            message: res.data?.message || '请求的资源不存在',
            data: null
        };
    } else {
        console.error(`请求失败 (${res.statusCode}):`, JSON.stringify(res.data));
        // 尝试从响应中获取更详细的错误信息
        const errorMessage = res.data?.message || 
                           res.data?.error || 
                           `请求失败 (${res.statusCode})`;
        
        // 记录详细错误日志
        console.error(`详细错误信息: ${errorMessage}`);
        console.error('请求URL:', res.config?.url);
        console.error('请求方法:', res.config?.method);
        console.error('请求头:', JSON.stringify(res.config?.header));
        
        // 返回错误响应而不是抛出错误，让调用者处理
        return {
            success: false,
            code: res.statusCode,
            message: errorMessage,
            data: null
        };
    }
};

// 将对象转换为URL查询字符串
const objectToQueryString = (params) => {
    if (!params) return '';
    
    // 过滤掉undefined和null的值
    const filteredParams = Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined && value !== null && value !== '') {
            acc[key] = value;
        }
        return acc;
    }, {});
    
    if (Object.keys(filteredParams).length === 0) return '';
    
    const parts = [];
    for (const [key, value] of Object.entries(filteredParams)) {
        if (Array.isArray(value)) {
            value.forEach((item) => {
                parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(item)}`);
            });
        } else {
            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
        }
    }
    return '?' + parts.join('&');
};

// 将request对象定义为export const
export const request = {
    get(url, params = {}, options = {}) {
        return new Promise((resolve, reject) => {
            // 处理参数
            if (typeof options === 'boolean') {
                options = { requireAuth: options };
            }
            
            // 如果需要认证，检查token
            const requireAuth = options.requireAuth !== false;
            if (requireAuth && !checkToken()) {
                reject(new Error('未登录或登录已过期'));
                return;
            }

            // 确保params是对象
            params = params || {};

            // 构建查询字符串
            let queryString = '';
            try {
                queryString = Object.entries(params)
                    .filter(([_, value]) => value !== undefined && value !== null && value !== '')
                    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
                    .join('&');
            } catch (error) {
                console.error('构建查询字符串失败:', error, '参数:', params);
                queryString = '';
            }

            // 处理额外的查询参数
            if (options && options.params) {
                try {
                    const extraParams = Object.entries(options.params || {})
                .filter(([_, value]) => value !== undefined && value !== null && value !== '')
                .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
                .join('&');
                    
                    if (extraParams) {
                        queryString = queryString ? `${queryString}&${extraParams}` : extraParams;
                    }
                } catch (error) {
                    console.error('构建额外查询参数失败:', error, '参数:', options.params);
                }
            }

            const fullUrl = BASE_URL + processUrl(url) + (queryString ? `?${queryString}` : '');
            
            console.log('Making GET request to:', fullUrl);
            console.log('Request params:', params);

            uni.request({
                url: fullUrl,
                method: 'GET',
                header: createHeaders(requireAuth),
                success: (res) => {
                    try {
                        const data = handleResponse(res);
                        resolve(data);
                    } catch (error) {
                        reject(error);
                    }
                },
                fail: (err) => {
                    console.error('Request failed:', err);
                    reject(new Error('网络请求失败'));
                }
            });
        });
    },

    post(url, data = {}, options = {}) {
        return new Promise((resolve, reject) => {
            // 解析requireAuth参数
            const requireAuth = options === false ? false : (options.requireAuth !== false);
            
            // 如果需要认证，检查token
            if (requireAuth && !checkToken()) {
                reject(new Error('未登录或登录已过期'));
                return;
            }

            let fullUrl = BASE_URL + processUrl(url);
            
            // 处理查询参数
            if (options && typeof options === 'object' && options.params) {
                const params = options.params;
                const queryString = Object.entries(params)
                    .filter(([_, value]) => value !== undefined && value !== null && value !== '')
                    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
                    .join('&');
                if (queryString) {
                    fullUrl += (fullUrl.includes('?') ? '&' : '?') + queryString;
                }
            }

            console.log('请求URL:', fullUrl);
            console.log('请求方法: POST');
            console.log('请求数据:', JSON.stringify(data));
            console.log('请求头:', JSON.stringify(createHeaders(requireAuth)));

            uni.request({
                url: fullUrl,
                method: 'POST',
                data,
                header: createHeaders(requireAuth),
                success: (res) => {
                    console.log('原始响应:', JSON.stringify(res));
                    try {
                        const data = handleResponse(res);
                        console.log('处理后的响应数据:', JSON.stringify(data));
                        resolve(data);
                    } catch (error) {
                        console.error('响应处理错误:', error.message);
                        reject(error);
                    }
                },
                fail: (err) => {
                    console.error('请求失败:', JSON.stringify(err));
                    reject(new Error('网络请求失败'));
                }
            });
        });
    },

    put(url, data = {}, requireAuth = true) {
        return new Promise((resolve, reject) => {
            // 如果需要认证，检查token
            if (requireAuth && !checkToken()) {
                reject(new Error('未登录或登录已过期'));
                return;
            }

            const fullUrl = BASE_URL + processUrl(url);
            console.log('Making PUT request to:', fullUrl);
            console.log('Request data:', data);

            uni.request({
                url: fullUrl,
                method: 'PUT',
                data,
                header: createHeaders(requireAuth),
                success: (res) => {
                    try {
                        const data = handleResponse(res);
                        resolve(data);
                    } catch (error) {
                        reject(error);
                    }
                },
                fail: (err) => {
                    console.error('Request failed:', err);
                    reject(new Error('网络请求失败'));
                }
            });
        });
    },

    delete(url, requireAuth = true) {
        return new Promise((resolve, reject) => {
            // 如果需要认证，检查token
            if (requireAuth && !checkToken()) {
                reject(new Error('未登录或登录已过期'));
                return;
            }

            const fullUrl = BASE_URL + processUrl(url);
            console.log('Making DELETE request to:', fullUrl);

            uni.request({
                url: fullUrl,
                method: 'DELETE',
                header: createHeaders(requireAuth),
                success: (res) => {
                    try {
                        const data = handleResponse(res);
                        resolve(data);
                    } catch (error) {
                        reject(error);
                    }
                },
                fail: (err) => {
                    console.error('Request failed:', err);
                    reject(new Error('网络请求失败'));
                }
            });
        });
    },
    
    // 添加通用请求方法，支持直接传入配置对象
    request(config) {
        return new Promise((resolve, reject) => {
            // 默认配置
            const defaultConfig = {
                method: 'GET',
                header: createHeaders(true),
                url: ''
            };
            
            // 合并配置
            const finalConfig = { ...defaultConfig, ...config };
            
            // 处理URL
            if (!finalConfig.url.startsWith('http')) {
                finalConfig.url = BASE_URL + processUrl(finalConfig.url);
            }
            
            // 处理URL参数
            if (finalConfig.params) {
                const queryString = objectToQueryString(finalConfig.params);
                if (queryString) {
                    finalConfig.url += queryString;
                }
            }
            
            console.log(`发送 ${finalConfig.method} 请求:`, finalConfig.url);
            
            uni.request({
                ...finalConfig,
                success: (res) => {
                    try {
                        const data = handleResponse(res);
                        resolve(data);
                    } catch (error) {
                        reject(error);
                    }
                },
                fail: (err) => {
                    console.error('请求失败:', err);
                    reject(err);
                }
            });
        });
    }
};

// 添加默认导出方法，支持直接传入配置对象
export default function(config) {
    if (typeof config === 'string') {
        // 如果传入的是字符串，当作URL处理
        return request.get(config);
    } else if (typeof config === 'object') {
        // 如果传入的是对象，使用通用请求方法
        return request.request(config);
    }
    return Promise.reject(new Error('无效的请求配置'));
}